/**
 * WebSocket日志IPC处理器
 * 负责处理WebSocket日志的写入、读取和清理
 */

import { ipcMain, app } from 'electron'
import fs from 'fs'
import path from 'path'
import { fileURLToPath } from 'node:url'

// 获取当前文件的目录路径（ES模块兼容）
const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)

// WebSocket日志文件管理 - 按天分割日志文件
const LOG_DIR = app.isPackaged 
  ? path.join(path.dirname(app.getPath('exe')), 'logs')  // 生产环境：安装目录下的logs文件夹
  : path.join(__dirname, '..', 'logs')                  // 开发环境：项目目录

// 获取当前日期的日志文件名
function getLogFileName(): string {
  const today = new Date()
  const dateStr = today.toISOString().split('T')[0] // YYYY-MM-DD格式
  return `websocket-${dateStr}.log`
}

// 获取当前日志文件路径
function getCurrentLogFile(): string {
  return path.join(LOG_DIR, getLogFileName())
}

const MAX_LOG_SIZE = 10 * 1024 * 1024 // 10MB
const MAX_LOG_FILES = 10 // 保留10天的日志文件

/**
 * 确保日志目录存在
 */
function ensureLogDir(): void {
  if (!fs.existsSync(LOG_DIR)) {
    fs.mkdirSync(LOG_DIR, { recursive: true })
  }
}

/**
 * 清理旧日志文件
 */
function cleanupOldLogs(): void {
  try {
    const files = fs.readdirSync(LOG_DIR)
    const logFiles = files
      .filter(file => file.startsWith('websocket-') && file.endsWith('.log'))
      .map(file => ({
        name: file,
        path: path.join(LOG_DIR, file),
        stats: fs.statSync(path.join(LOG_DIR, file)),
        date: extractDateFromFileName(file)
      }))
      .filter(file => file.date) // 过滤掉无法解析日期的文件
      .sort((a, b) => b.date.getTime() - a.date.getTime()) // 按日期降序排列

    // 删除超出数量限制的文件（保留最近10天）
    if (logFiles.length > MAX_LOG_FILES) {
      for (let i = MAX_LOG_FILES; i < logFiles.length; i++) {
        fs.unlinkSync(logFiles[i].path)
        console.log(`删除旧日志文件: ${logFiles[i].name}`)
      }
    }

    // 检查当前日志文件大小（如果超过限制，创建新的时间戳文件）
    const currentLogFile = getCurrentLogFile()
    if (fs.existsSync(currentLogFile)) {
      const stats = fs.statSync(currentLogFile)
      if (stats.size > MAX_LOG_SIZE) {
        // 创建带时间戳的新文件
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
        const newName = `websocket-${timestamp}.log`
        fs.renameSync(currentLogFile, path.join(LOG_DIR, newName))
        console.log(`日志文件过大，已重命名为: ${newName}`)
      }
    }
  } catch (error) {
    console.error('清理日志文件失败:', error)
  }
}

/**
 * 从文件名中提取日期
 */
function extractDateFromFileName(fileName: string): Date | null {
  try {
    // 匹配 websocket-YYYY-MM-DD.log 格式
    const match = fileName.match(/websocket-(\d{4}-\d{2}-\d{2})\.log/)
    if (match) {
      return new Date(match[1])
    }
    return null
  } catch (error) {
    return null
  }
}

/**
 * 写入WebSocket日志
 */
async function writeLog(logLine: string): Promise<{ success: boolean; error?: string }> {
  try {
    ensureLogDir()
    const currentLogFile = getCurrentLogFile()
    fs.appendFileSync(currentLogFile, logLine + '\n', 'utf8')
    return { success: true }
  } catch (error) {
    console.error('写入WebSocket日志失败:', error)
    return { success: false, error: (error as Error).message }
  }
}

/**
 * 获取WebSocket日志
 */
async function getLogs(options: { lines?: number; category?: string; date?: string } = {}): Promise<{ success: boolean; logs?: string[]; error?: string }> {
  try {
    // 确定要读取的日志文件
    let logFile: string
    if (options.date) {
      // 指定日期的日志文件
      logFile = path.join(LOG_DIR, `websocket-${options.date}.log`)
    } else {
      // 默认读取今天的日志文件
      logFile = getCurrentLogFile()
    }

    if (!fs.existsSync(logFile)) {
      return { success: true, logs: [] }
    }

    const content = fs.readFileSync(logFile, 'utf8')
    let lines = content.split('\n').filter(line => line.trim())

    // 按类别过滤
    if (options.category) {
      lines = lines.filter(line => line.includes(`| ${options.category} |`))
    }

    // 限制行数
    if (options.lines && options.lines > 0) {
      lines = lines.slice(-options.lines)
    }

    return { success: true, logs: lines }
  } catch (error) {
    console.error('读取WebSocket日志失败:', error)
    return { success: false, error: (error as Error).message }
  }
}

/**
 * 清理WebSocket日志
 */
async function clearLogs(): Promise<{ success: boolean; error?: string }> {
  try {
    // 清理所有日志文件
    const files = fs.readdirSync(LOG_DIR)
    const logFiles = files.filter(file => file.startsWith('websocket-') && file.endsWith('.log'))
    
    for (const file of logFiles) {
      fs.unlinkSync(path.join(LOG_DIR, file))
    }
    
    return { success: true }
  } catch (error) {
    console.error('清理WebSocket日志失败:', error)
    return { success: false, error: (error as Error).message }
  }
}

/**
 * 获取日志文件信息
 */
async function getLogInfo(): Promise<{ success: boolean; info?: any; error?: string }> {
  try {
    const currentLogFile = getCurrentLogFile()
    const files = fs.readdirSync(LOG_DIR)
    const logFiles = files.filter(file => file.startsWith('websocket-') && file.endsWith('.log'))
    
    if (!fs.existsSync(currentLogFile)) {
      return { 
        success: true, 
        info: { 
          exists: false,
          logDir: LOG_DIR,
          currentLogFile: currentLogFile,
          isPackaged: app.isPackaged,
          totalFiles: logFiles.length,
          maxFiles: MAX_LOG_FILES
        } 
      }
    }

    const stats = fs.statSync(currentLogFile)

    return {
      success: true,
      info: {
        exists: true,
        logDir: LOG_DIR,
        currentLogFile: currentLogFile,
        isPackaged: app.isPackaged,
        size: stats.size,
        sizeFormatted: formatFileSize(stats.size),
        lastModified: stats.mtime,
        totalFiles: logFiles.length,
        maxFiles: MAX_LOG_FILES,
        logFiles: logFiles.sort().reverse() // 按文件名降序排列
      }
    }
  } catch (error) {
    console.error('获取日志信息失败:', error)
    return { success: false, error: (error as Error).message }
  }
}

/**
 * 格式化文件大小
 */
function formatFileSize(bytes: number): string {
  if (bytes === 0) return '0 B'
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 注册WebSocket日志IPC处理器
 */
export function registerWebSocketLogHandlers(): void {
  ensureLogDir()
  cleanupOldLogs()

  // 写入日志
  ipcMain.handle('write-ws-log', async (event, logLine: string) => {
    return await writeLog(logLine)
  })

  // 获取日志
  ipcMain.handle('get-ws-logs', async (event, options: { lines?: number; category?: string; date?: string } = {}) => {
    return await getLogs(options)
  })

  // 清理日志
  ipcMain.handle('clear-ws-logs', async () => {
    return await clearLogs()
  })

  // 获取日志信息
  ipcMain.handle('get-ws-log-info', async () => {
    return await getLogInfo()
  })

  console.log('WebSocket日志IPC处理器注册完成')
}

/**
 * 导出工具函数供其他模块使用
 */
export {
  ensureLogDir,
  cleanupOldLogs,
  writeLog,
  getLogs,
  clearLogs,
  getLogInfo,
  getLogFileName,
  getCurrentLogFile,
  extractDateFromFileName,
  LOG_DIR,
  MAX_LOG_SIZE,
  MAX_LOG_FILES
}
